These 5 new features in C# 12 - Change your way of coding

C# 12 introduces several exciting new features aimed at improving developer productivity, enhancing language expressiveness, and providing better performance. Below are five new features in C# 12 that stand out:

1. Primary Constructors for Classes

C# 12 brings primary constructors for classes, a feature previously available only for structs. This simplifies the way you declare constructors and initialize class properties.

public class Person(string name, int age)
{
    public string Name { get; } = name;
    public int Age { get; } = age;
}

var person = new Person("John Doe", 30);
Console.WriteLine($"{person.Name}, {person.Age}");

With primary constructors, the parameters are passed directly when creating an instance of the class. This eliminates the need for boilerplate constructor code and reduces redundancy.

2. Collection Expressions

Collection expressions make it easier to work with collections by allowing you to initialize, filter, and manipulate collections more succinctly, without relying on LINQ for every operation.

var numbers = [1, 2, 3, 4, 5];  // New collection initialization syntax
var evens = [n for n in numbers where n % 2 == 0];  // Filtering with collection expression

Console.WriteLine(string.Join(", ", evens));  // Output: 2, 4

This new syntax provides a cleaner, more readable way of constructing and filtering collections, similar to what’s available in languages like Python.

3. Default Lambda Expressions

In C# 12, you can define default lambda expressions, which is helpful when using lambdas as default arguments for parameters. This makes lambdas more flexible and useful in cases where default values are commonly used.

void ProcessNumbers(IEnumerable<int> numbers, Func<int, bool> filter = static x => true)
{
    foreach (var number in numbers)
    {
        if (filter(number))
        {
            Console.WriteLine(number);
        }
    }
}

var numbers = new List<int> { 1, 2, 3, 4, 5 };
ProcessNumbers(numbers, x => x % 2 == 0);  // Filters even numbers
ProcessNumbers(numbers);  // Uses default filter (returns true for all numbers)

This feature provides more power and flexibility when using lambdas, especially in API design.

4. Using Alias for Any Type

In C# 12, the using directive now supports type aliases for any type, not just namespaces. This allows you to create more meaningful and concise names for types, including generic types, which is particularly useful when working with complex types.

using Numbers = System.Collections.Generic.List<int>;

Numbers myNumbers = new() { 1, 2, 3, 4, 5 };
Console.WriteLine(string.Join(", ", myNumbers));  // Output: 1, 2, 3, 4, 5

This feature enhances code readability and makes it easier to work with long or complex type names.

5. Improved `constexpr` (Constant Expressions)

C# 12 enhances constant expressions, allowing more expressions to be evaluated at compile time. This includes some types of method calls, making it possible to compute values at compile time that were previously only computable at runtime.

public class MathConstants
{
    public const double Pi = Math.PI;  // Pi is computed as a constant expression
    public const double Circumference(double radius) => 2 * Pi * radius;  // Compile-time constant expression
}

Console.WriteLine(MathConstants.Circumference(5));  // Output: 31.41592653589793

This improvement can significantly optimize performance by reducing runtime computation and enhancing compile-time validation.

Conclusion

C# 12 adds significant features that improve the overall developer experience. These five features — Primary Constructors, Collection Expressions, Default Lambdas, Type Aliases, and Improved Constant Expressions — make C# more powerful, expressive, and easier to work with in modern applications. These changes demonstrate the language’s continuing evolution, ensuring that C# remains one of the most productive and flexible programming languages available.

DotNet Full Stack Dev

Search This Blog